<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>float128</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="mpfr_float.html" title="mpfr_float">
<link rel="next" href="fp_eg.html" title="Examples">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fp_eg.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.float128"></a><a class="link" href="float128.html" title="float128">float128</a>
</h4></div></div></div>
<p>
          <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
        </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>

<span class="keyword">class</span> <span class="identifier">float128_backend</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">float128_backend</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;</span>    <span class="identifier">float128</span><span class="special">;</span>

<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
          The <code class="computeroutput"><span class="identifier">float128</span></code> number type
          is a very thin wrapper around GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
          or Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data types
          and provides an real-number type that is a drop-in replacement for the
          native C++ floating-point types, but with a 113 bit mantissa, and compatible
          with FORTRAN's 128-bit QUAD real.
        </p>
<p>
          All the usual standard library and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
          support are available, performance should be equivalent to the underlying
          native types: for example the LINPACK benchmarks for GCC's <code class="computeroutput"><span class="identifier">__float128</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">float128</span></code>
          both achieved 5.6 MFLOPS<a href="#ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote" name="boost_multiprecision.tut.floats.float128.f0"><sup class="footnote">[3]</sup></a>.
        </p>
<p>
          As well as the usual conversions from arithmetic and string types, instances
          of <code class="computeroutput"><span class="identifier">float128</span></code> are copy constructible
          and assignable from GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
          and Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data
          types.
        </p>
<p>
          It's also possible to access the underlying <code class="computeroutput"><span class="identifier">__float128</span></code>
          or <code class="computeroutput"><span class="identifier">_Quad</span></code> type via the
          <code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
          member function of <code class="computeroutput"><span class="identifier">float128_backend</span></code>.
        </p>
<p>
          Things you should know when using this type:
        </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
              Default constructed <code class="computeroutput"><span class="identifier">float128</span></code>s
              have the value zero.
            </li>
<li class="listitem">
              This backend supports rvalue-references and is move-aware, making instantiations
              of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
              move aware.
            </li>
<li class="listitem">
              This type is fully <code class="computeroutput"><span class="keyword">constexpr</span></code>
              aware - basic constexpr arithmetic is supported from C++14 and onwards,
              comparisons, plus the functions <code class="computeroutput"><span class="identifier">fabs</span></code>,
              <code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">fpclassify</span></code>, <code class="computeroutput"><span class="identifier">isnormal</span></code>,
              <code class="computeroutput"><span class="identifier">isfinite</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code> and <code class="computeroutput"><span class="identifier">isnan</span></code>
              are also supported if either the compiler implements C++20's <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code>,
              or if the compiler is GCC.
            </li>
<li class="listitem">
              It is not possible to round-trip objects of this type to and from a
              string and get back exactly the same value when compiled with Intel's
              C++ compiler and using <code class="computeroutput"><span class="identifier">_Quad</span></code>
              as the underlying type: this is a current limitation of our code. Round
              tripping when using <code class="computeroutput"><span class="identifier">__float128</span></code>
              as the underlying type is possible (both for GCC and Intel).
            </li>
<li class="listitem">
              Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            </li>
<li class="listitem">
              Division by zero results in an infinity being produced.
            </li>
<li class="listitem">
              Type <code class="computeroutput"><span class="identifier">float128</span></code> can be
              used as a literal type (constexpr support).
            </li>
<li class="listitem">
              Type <code class="computeroutput"><span class="identifier">float128</span></code> can be
              used for full <code class="computeroutput"><span class="keyword">constexpr</span></code>
              arithmetic from C++14 and later with GCC. The functions <code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">fabs</span></code>,
              <code class="computeroutput"><span class="identifier">fpclassify</span></code>, <code class="computeroutput"><span class="identifier">isnan</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code>,
              <code class="computeroutput"><span class="identifier">isfinite</span></code> and <code class="computeroutput"><span class="identifier">isnormal</span></code> are also <code class="computeroutput"><span class="keyword">constexpr</span></code>,
              but the transcendental functions are not.
            </li>
<li class="listitem">
              When using the Intel compiler, the underlying type defaults to <code class="computeroutput"><span class="identifier">__float128</span></code> if it's available and
              <code class="computeroutput"><span class="identifier">_Quad</span></code> if not. You can
              override the default by defining either <code class="computeroutput"><span class="identifier">BOOST_MP_USE_FLOAT128</span></code>
              or <code class="computeroutput"><span class="identifier">BOOST_MP_USE_QUAD</span></code>.
            </li>
<li class="listitem">
              When the underlying type is Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code>
              type, the code must be compiled with the compiler option <code class="computeroutput"><span class="special">-</span><span class="identifier">Qoption</span><span class="special">,</span><span class="identifier">cpp</span><span class="special">,--</span><span class="identifier">extended_float_type</span></code>.
            </li>
<li class="listitem">
              When compiling with <code class="computeroutput"><span class="identifier">gcc</span></code>,
              you need to use the flag <code class="computeroutput"><span class="special">--</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">gnu</span><span class="special">++</span><span class="number">11</span><span class="special">/</span><span class="number">14</span><span class="special">/</span><span class="number">17</span></code>,
              as the suffix 'Q' is a GNU extension. Compilation fails with the flag
              <code class="computeroutput"><span class="special">--</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">c</span><span class="special">++</span><span class="number">11</span><span class="special">/</span><span class="number">14</span><span class="special">/</span><span class="number">17</span></code> unless you also use <code class="computeroutput"><span class="special">-</span><span class="identifier">fext</span><span class="special">-</span><span class="identifier">numeric</span><span class="special">-</span><span class="identifier">literals</span></code>.
            </li>
<li class="listitem">
              You will need to link to <code class="computeroutput"><span class="identifier">libquadmath</span><span class="special">.</span><span class="identifier">dll</span></code>
              with the link command <code class="computeroutput"><span class="special">-</span><span class="identifier">lquadmath</span></code> and ensure that the DLL
              is visible by the linker. If you are using the B2/bjam build system
              then commands<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">linkflags</span><span class="special">&gt;-</span><span class="identifier">lQUADMATH</span></code>
              and <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">linkflags</span><span class="special">&gt;-</span><span class="identifier">L</span><span class="string">"path/to/lib"</span></code> will be needed.
            </li>
<li class="listitem">
              The values shown by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;</span></code> and extremely close <span class="emphasis"><em>but
              not identical</em></span> to those from the equivalent precision and
              range multiprecision types <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_bin_float_quad</span><span class="special">&gt;</span></code> and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">cpp_dec_float_quad</span><span class="special">&gt;</span></code>.
            </li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.float128.h0"></a>
          <span class="phrase"><a name="boost_multiprecision.tut.floats.float128.float128_example"></a></span><a class="link" href="float128.html#boost_multiprecision.tut.floats.float128.float128_example">float128
          example:</a>
        </h6>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
   <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span> <span class="comment">// Potential to cause name collisions?</span>
   <span class="comment">// using boost::multiprecision::float128; // is safer.</span>
</pre>
<p>
          The type float128 provides operations at 128-bit precision with <a href="https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#IEEE_754_quadruple-precision_binary_floating-point_format:_binary128" target="_top">Quadruple-precision
          floating-point format</a> and have full <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
          support:
        </p>
<pre class="programlisting"><span class="identifier">float128</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
</pre>
<p>
          There are 15 bits of (biased) binary exponent and 113-bits of significand
          precision
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          or 33 decimal places:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          We can use any C++ std library function, so let's show all the at-most
          36 potentially significant digits, and any trailing zeros, as well:
        </p>
<pre class="programlisting"> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">setf</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">showpoint</span><span class="special">);</span> <span class="comment">// Include any trailing zeros.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
   <span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Shows log(2) = 0.693147180559945309417232121458176575</span>
</pre>
<p>
          We can also use any function from Boost.Math, for example, the 'true gamma'
          function <code class="computeroutput"><span class="identifier">tgamma</span></code>:
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          And since we have an extended exponent range, we can generate some really
          large numbers here (4.02387260077093773543702433923004111e+2564):
        </p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">float128</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
          We can declare constants using GCC or Intel's native types, and literals
          with the Q suffix, and these can be declared <code class="computeroutput"><span class="keyword">constexpr</span></code>
          if required:
        </p>
<pre class="programlisting"><span class="comment">// std::numeric_limits&lt;float128&gt;::max_digits10 = 36</span>
<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="number">3.14159265358979323846264338327950288</span><span class="identifier">Q</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pi = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//pi = 3.14159265358979323846264338327950280</span>
</pre>
<p>
          Values for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;</span></code>
          are:
        </p>
<pre class="programlisting"><span class="identifier">GCC</span> <span class="number">8.1</span><span class="special">.</span><span class="number">0</span>

<span class="identifier">Type</span> <span class="identifier">name</span> <span class="identifier">is</span> <span class="identifier">float128_t</span><span class="special">:</span>
<span class="identifier">Type</span> <span class="identifier">is</span> <span class="identifier">g</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_fundamental</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_signed</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_unsigned</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_trivial</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_standard_layout</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_pod</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_exact</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is</span> <span class="identifier">bounded</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_modulo</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_iec559</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">traps</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">tinyness_before</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.18973149535723176508575932662800702e+4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">min</span><span class="special">()</span> <span class="special">=</span> <span class="number">3.36210314311209350626267781732175260e-4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">lowest</span><span class="special">()</span> <span class="special">=</span> <span class="special">-</span><span class="number">1.18973149535723176508575932662800702e+4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">min_exponent</span> <span class="special">=</span> <span class="special">-</span><span class="number">16381</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max_exponent</span> <span class="special">=</span> <span class="number">16384</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">epsilon</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.92592994438723585305597794258492732e-34</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">radix</span> <span class="special">=</span> <span class="number">2</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">digits</span> <span class="special">=</span> <span class="number">113</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">digits10</span> <span class="special">=</span> <span class="number">33</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max_digits10</span> <span class="special">=</span> <span class="number">36</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">has</span> <span class="identifier">denorm</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">denorm</span> <span class="identifier">min</span> <span class="special">=</span> <span class="number">6.47517511943802511092443895822764655e-4966</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_loss</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">limits</span><span class="special">::</span><span class="identifier">has_signaling_NaN</span> <span class="special">==</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">quiet_NaN</span> <span class="special">=</span> <span class="identifier">nan</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">infinity</span> <span class="special">=</span> <span class="identifier">inf</span>
</pre>
<div class="footnotes">
<br><hr style="width:100; text-align:left;margin-left: 0">
<div id="ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote"><p><a href="#boost_multiprecision.tut.floats.float128.f0" class="para"><sup class="para">[3] </sup></a>
            On 64-bit Ubuntu 11.10, GCC-4.8.0, Intel Core 2 Duo T5800.
          </p></div>
</div>
</div>
<div class="copyright-footer">Copyright © 2002-2020 John
      Maddock and Christopher Kormanyos<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fp_eg.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
